
 
module multiplier(
 
iClk, // input clock
 
iReset, // reset signal
 
iReady, // indicates inputs are ready
 
oDone, // indicates that the result is ready
 
iMultiplier, // 8-bit multiplier [7:0]
 
iMultiplicand, // 8-bit multiplicand [7:0]
 
oProduct // 16-bit product [15:0]
 
);
 

 
input iClk;
 
input [7:0] iMultiplier, iMultiplicand;
 
input iReset, iReady;
 

 
output oDone;
 
output [15:0] oProduct;
 


wire [7:0] am0,am1,am2,am3,am4,am5,am6,am7;
wire [7:0] sum0,sum1,sum2,sum3,sum4,sum5,sum6,sum7;
wire [7:0] c;
wire [7:0] inier, inicand;
wire [7:0] axor, bxor;
wire [15:0] inproduct, convert;
wire sign;
 


 
xor(axor[0], iMultiplier[0],iMultiplier[7]);
xor(axor[1], iMultiplier[1],iMultiplier[7]);
xor(axor[2], iMultiplier[2],iMultiplier[7]);
xor(axor[3], iMultiplier[3],iMultiplier[7]);
xor(axor[4], iMultiplier[4],iMultiplier[7]);
xor(axor[5], iMultiplier[5],iMultiplier[7]);
xor(axor[6], iMultiplier[6],iMultiplier[7]);
xor(axor[7], iMultiplier[7],iMultiplier[7]);
RCA rca_axor(axor, {1'b0, 1'b0, 1'b0, 1'b0, 1'b0, 1'b0, 1'b0, iMultiplier[7]}, 1'b0, inier, );

xor(bxor[0], iMultiplicand[0], iMultiplicand[7]);
xor(bxor[1], iMultiplicand[1], iMultiplicand[7]);
xor(bxor[2], iMultiplicand[2], iMultiplicand[7]);
xor(bxor[3], iMultiplicand[3], iMultiplicand[7]);
xor(bxor[4], iMultiplicand[4], iMultiplicand[7]);
xor(bxor[5], iMultiplicand[5], iMultiplicand[7]);
xor(bxor[6], iMultiplicand[6], iMultiplicand[7]);
xor(bxor[7], iMultiplicand[7], iMultiplicand[7]);
RCA rca_bxor(bxor, {1'b0, 1'b0, 1'b0, 1'b0, 1'b0, 1'b0, 1'b0, iMultiplicand[7]}, 1'b0, inicand, );

and(am0[0], inicand[0],iClk,iReady,~iReset,inier[0]);
and(am0[1], inicand[1],iClk,iReady,~iReset,inier[0]);
and(am0[2], inicand[2],iClk,iReady,~iReset,inier[0]);
and(am0[3], inicand[3],iClk,iReady,~iReset,inier[0]);
and(am0[4], inicand[4],iClk,iReady,~iReset,inier[0]);
and(am0[5], inicand[5],iClk,iReady,~iReset,inier[0]);
and(am0[6], inicand[6],iClk,iReady,~iReset,inier[0]);
and(am0[7], inicand[7],iClk,iReady,~iReset,inier[0]);

and(am1[0], inicand[0],iClk,iReady,~iReset,inier[1]);
and(am1[1], inicand[1],iClk,iReady,~iReset,inier[1]);
and(am1[2], inicand[2],iClk,iReady,~iReset,inier[1]);
and(am1[3], inicand[3],iClk,iReady,~iReset,inier[1]);
and(am1[4], inicand[4],iClk,iReady,~iReset,inier[1]);
and(am1[5], inicand[5],iClk,iReady,~iReset,inier[1]);
and(am1[6], inicand[6],iClk,iReady,~iReset,inier[1]);
and(am1[7], inicand[7],iClk,iReady,~iReset,inier[1]);

and(am2[0], inicand[0],iClk,iReady,~iReset,inier[2]);
and(am2[1], inicand[1],iClk,iReady,~iReset,inier[2]);
and(am2[2], inicand[2],iClk,iReady,~iReset,inier[2]);
and(am2[3], inicand[3],iClk,iReady,~iReset,inier[2]);
and(am2[4], inicand[4],iClk,iReady,~iReset,inier[2]);
and(am2[5], inicand[5],iClk,iReady,~iReset,inier[2]);
and(am2[6], inicand[6],iClk,iReady,~iReset,inier[2]);
and(am2[7], inicand[7],iClk,iReady,~iReset,inier[2]);
and(am2[0], inicand[0],iClk,iReady,~iReset,inier[2]);

and(am3[1], inicand[1],iClk,iReady,~iReset,inier[3]);
and(am3[2], inicand[2],iClk,iReady,~iReset,inier[3]);
and(am3[3], inicand[3],iClk,iReady,~iReset,inier[3]);
and(am3[4], inicand[4],iClk,iReady,~iReset,inier[3]);
and(am3[5], inicand[5],iClk,iReady,~iReset,inier[3]);
and(am3[6], inicand[6],iClk,iReady,~iReset,inier[3]);
and(am3[7], inicand[7],iClk,iReady,~iReset,inier[3]);

and(am4[0], inicand[0],iClk,iReady,~iReset,inier[4]);
and(am4[1], inicand[1],iClk,iReady,~iReset,inier[4]);
and(am4[2], inicand[2],iClk,iReady,~iReset,inier[4]);
and(am4[3], inicand[3],iClk,iReady,~iReset,inier[4]);
and(am4[4], inicand[4],iClk,iReady,~iReset,inier[4]);
and(am4[5], inicand[5],iClk,iReady,~iReset,inier[4]);
and(am4[6], inicand[6],iClk,iReady,~iReset,inier[4]);
and(am4[7], inicand[7],iClk,iReady,~iReset,inier[4]);

and(am5[0], inicand[0],iClk,iReady,~iReset,inier[5]);
and(am5[1], inicand[1],iClk,iReady,~iReset,inier[5]);
and(am5[2], inicand[2],iClk,iReady,~iReset,inier[5]);
and(am5[3], inicand[3],iClk,iReady,~iReset,inier[5]);
and(am5[4], inicand[4],iClk,iReady,~iReset,inier[5]);
and(am5[5], inicand[5],iClk,iReady,~iReset,inier[5]);
and(am5[6], inicand[6],iClk,iReady,~iReset,inier[5]);
and(am5[7], inicand[7],iClk,iReady,~iReset,inier[5]);

and(am6[0], inicand[0],iClk,iReady,~iReset,inier[6]);
and(am6[1], inicand[1],iClk,iReady,~iReset,inier[6]);
and(am6[2], inicand[2],iClk,iReady,~iReset,inier[6]);
and(am6[3], inicand[3],iClk,iReady,~iReset,inier[6]);
and(am6[4], inicand[4],iClk,iReady,~iReset,inier[6]);
and(am6[5], inicand[5],iClk,iReady,~iReset,inier[6]);
and(am6[6], inicand[6],iClk,iReady,~iReset,inier[6]);
and(am6[7], inicand[7],iClk,iReady,~iReset,inier[6]);

and(am7[1], inicand[1],iClk,iReady,~iReset,inier[7]);
and(am7[2], inicand[2],iClk,iReady,~iReset,inier[7]);
and(am7[3], inicand[3],iClk,iReady,~iReset,inier[7]);
and(am7[4], inicand[4],iClk,iReady,~iReset,inier[7]);
and(am7[5], inicand[5],iClk,iReady,~iReset,inier[7]);
and(am7[6], inicand[6],iClk,iReady,~iReset,inier[7]);
and(am7[7], inicand[7],iClk,iReady,~iReset,inier[7]);
 
RCA rca0(am0,inier,1'b0,{sum0[7],sum0[6],sum0[5],sum0[4],sum0[3],sum0[2],sum0[1],inproduct[0]},c[0]);
RCA rca1(am1,{c[0],sum0[7],sum0[6],sum0[5],sum0[4],sum0[3],sum0[2],sum0[1]},1'b0,{sum1[7],sum1[6],sum1[5],sum1[4],sum1[3],sum1[2],sum1[1],inproduct[1]},c[1]);
RCA rca2(am2,{c[1],sum1[7],sum1[6],sum1[5],sum1[4],sum1[3],sum1[2],sum1[1]},1'b0,{sum2[7],sum2[6],sum2[5],sum2[4],sum2[3],sum2[2],sum2[1],inproduct[2]},c[2]);
RCA rca3(am3,{c[2],sum2[7],sum2[6],sum2[5],sum2[4],sum2[3],sum2[2],sum2[1]},1'b0,{sum3[7],sum3[6],sum3[5],sum3[4],sum3[3],sum3[2],sum3[1],inproduct[3]},c[3]);
RCA rca4(am4,{c[3],sum3[7],sum3[6],sum3[5],sum3[4],sum3[3],sum3[2],sum3[1]},1'b0,{sum4[7],sum4[6],sum4[5],sum4[4],sum4[3],sum4[2],sum4[1],inproduct[4]},c[4]);
RCA rca5(am5,{c[4],sum4[7],sum4[6],sum4[5],sum4[4],sum4[3],sum4[2],sum4[1]},1'b0,{sum5[7],sum5[6],sum5[5],sum5[4],sum5[3],sum5[2],sum5[1],inproduct[5]},c[5]);
RCA rca6(am6,{c[5],sum5[7],sum5[6],sum5[5],sum5[4],sum5[3],sum5[2],sum5[1]},1'b0,{sum6[7],sum6[6],sum6[5],sum6[4],sum6[3],sum6[2],sum6[1],inproduct[6]},c[6]);
RCA rca7(am7,{c[6],sum6[7],sum6[6],sum6[5],sum6[4],sum6[3],sum6[2],sum6[1]},1'b0,{inproduct[14],inproduct[13],inproduct[12],inproduct[11],inproduct[10],inproduct[9],inproduct[8],inproduct[7]},inproduct[15]);

xor(sign, iMultiplier[7], iMultiplicand[7]);
xor(convert[0], inproduct[0], sign);
xor(convert[1], inproduct[1], sign);
xor(convert[2], inproduct[2], sign);
xor(convert[3], inproduct[3], sign);
xor(convert[4], inproduct[4], sign);
xor(convert[5], inproduct[5], sign);
xor(convert[6], inproduct[6], sign);
xor(convert[7], inproduct[7], sign);
xor(convert[8], inproduct[8], sign);
xor(convert[9], inproduct[9], sign);
xor(convert[10], inproduct[10], sign);
xor(convert[11], inproduct[11], sign);
xor(convert[12], inproduct[12], sign);
xor(convert[13], inproduct[13], sign);
xor(convert[14], inproduct[14], sign);
xor(convert[15], inproduct[15], sign);
RCA_16 rca_16(convert, {1'b0,1'b0,1'b0,1'b0,1'b0,1'b0,1'b0,1'b0,1'b0,1'b0, 1'b0, 1'b0, 1'b0, 1'b0, 1'b0, sign}, 1'b0, oProduct, ); 

assign oDone = 1'b1;


 

 
endmodule 





















//////////////////////////////////////////////////////////////////////////////////
 
//				sub module					//
 
//////////////////////////////////////////////////////////////////////////////////
 

 
//////////////////////////////////////////////////////////////////////////////////
 
// 		Half Adder 		//////////////////////////////////////////
 
//////////////////////////////////////////////////////////////////////////////////
 
module HA(A,B,S,Cout);
 

 
input A,B;
 
output S,Cout;
 

 
	xor(S,A,B);
 
	and(Cout,A,B);
 

 
endmodule
 

 
//////////////////////////////////////////////////////////////////////////////////
 
// 		Full Adder 		//////////////////////////////////////////	
 
//////////////////////////////////////////////////////////////////////////////////
 
module FA(A,B,Cin,S,Cout);
 

 
input A,B,Cin;
 
output S,Cout;
 

 
wire w1, w2, w3;
 

 
	HA ha0(A,B,w1,w2);
 
	HA ha1(w1,Cin,S,w3);
 
	or(Cout,w2,w3);
 

 
endmodule
 

 

 
//////////////////////////////////////////////////////////////////////////////////
 
// 	8 bit Ripple Carry Adder	//////////////////////////////////////////	
 
//////////////////////////////////////////////////////////////////////////////////
 
module RCA(A,B,C0,S,C8);
 

 
input [7:0]A;
 
input [7:0]B;
 
input C0;
 
output [7:0]S;
 
output C8;
 

 
wire C1,C2,C3,C4,C5,C6,C7;
 

 
	FA fa0(A[0],B[0],C0,S[0],C1);
 
	FA fa1(A[1],B[1],C1,S[1],C2);
 
	FA fa2(A[2],B[2],C2,S[2],C3);
 
	FA fa3(A[3],B[3],C3,S[3],C4);
 
	FA fa4(A[4],B[4],C4,S[4],C5);
 
	FA fa5(A[5],B[5],C5,S[5],C6);
 
	FA fa6(A[6],B[6],C6,S[6],C7);
 
	FA fa7(A[7],B[7],C7,S[7],C8);
 

 
endmodule
 

 
//////////////////////////////////////////////////////////////////////////////////
 
// 	16 bit Ripple Carry Adder	//////////////////////////////////////////	
 
//////////////////////////////////////////////////////////////////////////////////
 
module RCA_16(A,B,C0,S,C16);
 

 
input [15:0]A;
 
input [15:0]B;
 
input C0;
 
output [15:0]S;
 
output C16;
 

 
wire C1,C2,C3,C4,C5,C6,C7,C8,C9,C10,C11,C12,C13,C14,C15;
 

 
	FA fa0(A[0],B[0],C0,S[0],C1);
 
	FA fa1(A[1],B[1],C1,S[1],C2);
 
	FA fa2(A[2],B[2],C2,S[2],C3);
 
	FA fa3(A[3],B[3],C3,S[3],C4);
 
	FA fa4(A[4],B[4],C4,S[4],C5);
 
	FA fa5(A[5],B[5],C5,S[5],C6);
 
	FA fa6(A[6],B[6],C6,S[6],C7);
 
	FA fa7(A[7],B[7],C7,S[7],C8);
 
	FA fa8(A[8],B[8],C8,S[8],C9);
 
	FA fa9(A[9],B[9],C9,S[9],C10);
 
	FA fa10(A[10],B[10],C10,S[10],C11);
 
	FA fa11(A[11],B[11],C11,S[11],C12);
 
	FA fa12(A[12],B[12],C12,S[12],C13);
 
	FA fa13(A[13],B[13],C13,S[13],C14);
 
	FA fa14(A[14],B[14],C14,S[14],C15);
 
	FA fa15(A[15],B[15],C15,S[15],C16);
 

 
endmodule
 

 

 
//////////////////////////////////////////////////////////////////////////////////
 
// 	8 bit Adder and Subtracto	//////////////////////////////////////////	
 
//////////////////////////////////////////////////////////////////////////////////
 
module ALU(A,B,C0,S,C8);
 

 
input [7:0]A;
 
input [7:0]B;
 
input C0;
 
output [7:0]S;
 
output C8;
 

 
wire [7:0]N;
 

 
	xor(N[0],B[0],C0);
 
	xor(N[1],B[1],C0);
 
	xor(N[2],B[2],C0);
 
	xor(N[3],B[3],C0);
 
	xor(N[4],B[4],C0);
 
	xor(N[5],B[5],C0);
 
	xor(N[6],B[6],C0);
 
	xor(N[7],B[7],C0);
 

 
	RCA rca0(A,N,C0,S,C8);
 

 
endmodule
 

 
//////////////////////////////////////////////////////////////////////////////////
 
// 	     8 to 1 Multiplexer		//////////////////////////////////////////	
 
//////////////////////////////////////////////////////////////////////////////////
 
module MUX8(I7,I6,I5,I4,I3,I2,I1,I0,S2,S1,S0,O);
 

 
input I7,I6,I5,I4,I3,I2,I1,I0;
 
input S2,S1,S0;
 
output O;
 

 
wire n0, n1, n2, r0, r1, r2, r3, r4, r5, r6, r7;
 

 
	not(n0,S0);
 
	not(n1,S1);
 
	not(n2,S2);
 
	and(r0,n0,n1,n2,I0);
 
	and(r1,S0,n1,n2,I1);
 
	and(r2,n0,S1,n2,I2);
 
	and(r3,S0,S1,n2,I3);
 
	and(r4,n0,n1,S2,I4);
 
	and(r5,S0,n1,S2,I5);
 
	and(r6,n0,S1,S2,I6);
 
	and(r7,S0,S1,S2,I7);
 
	or(O,r0,r1,r2,r3,r4,r5,r6,r7);
 

 
endmodule
 

 

 
//////////////////////////////////////////////////////////////////////////////////
 
// 	     4 to 1 Multiplexer		//////////////////////////////////////////	
 
//////////////////////////////////////////////////////////////////////////////////
 
module MUX4(I3,I2,I1,I0,S1,S0,O);
 

 
input I3,I2,I1,I0;
 
input S1,S0;
 
output O;
 

 
wire n0, n1, r0, r1, r2, r3;
 

 
	not(n0,S0);
 
	not(n1,S1);
 
	and(r0,n0,n1,I0);
 
	and(r1,S0,n1,I1);
 
	and(r2,n0,S1,I2);
 
	and(r3,S0,S1,I3);
 
	or(O,r0,r1,r2,r3);
 

 
endmodule
 

 
//////////////////////////////////////////////////////////////////////////////////
 
// 		D FlipFlop 		//////////////////////////////////////////	
 
//////////////////////////////////////////////////////////////////////////////////
 
module DFF(D,C,Q,RESET);
 

 
input D, C,RESET;
 
output Q;
 
reg Q;
 
	
 
	always @ (posedge RESET or posedge C)
 
	begin
 
		if(RESET)
 
			Q <= 1'b0;
 
		else
 
			Q <= D;
 
	end
 
	
 
endmodule 
